<head><meta charset="UTF-8"></head><h1 class="heading">B+树索引的使用</h1>
<p>标签： MySQL是怎样运行的</p>
<hr>
<p>我们前边详细、详细又详细的唠叨了<code>InnoDB</code>存储引擎的<code>B+</code>树索引，我们必须熟悉下边这些结论：</p>
<ul>
<li>
<p>每个索引都对应一棵<code>B+</code>树，<code>B+</code>树分为好多层，最下边一层是叶子节点，其余的是内节点。所有<code>用户记录</code>都存储在<code>B+</code>树的叶子节点，所有<code>目录项记录</code>都存储在内节点。</p>
</li>
<li>
<p><code>InnoDB</code>存储引擎会自动为主键（如果没有它会自动帮我们添加）建立<code>聚簇索引</code>，聚簇索引的叶子节点包含完整的用户记录。</p>
</li>
<li>
<p>我们可以为自己感兴趣的列建立<code>二级索引</code>，<code>二级索引</code>的叶子节点包含的用户记录由<code>索引列 + 主键</code>组成，所以如果想通过<code>二级索引</code>来查找完整的用户记录的话，需要通过<code>回表</code>操作，也就是在通过<code>二级索引</code>找到主键值之后再到<code>聚簇索引</code>中查找完整的用户记录。</p>
</li>
<li>
<p><code>B+</code>树中每层节点都是按照索引列值从小到大的顺序排序而组成了双向链表，而且每个页内的记录（不论是用户记录还是目录项记录）都是按照索引列的值从小到大的顺序而形成了一个单链表。如果是<code>联合索引</code>的话，则页面和记录先按照<code>联合索引</code>前边的列排序，如果该列值相同，再按照<code>联合索引</code>后边的列排序。</p>
</li>
<li>
<p>通过索引查找记录是从<code>B+</code>树的根节点开始，一层一层向下搜索。由于每个页面都按照索引列的值建立了<code>Page Directory</code>（页目录），所以在这些页面中的查找非常快。</p>
</li>
</ul>
<p>如果你读上边的几点结论有些任何一点点疑惑的话，那下边的内容不适合你，回过头先去看前边的内容去。</p>
<h2 class="heading">索引的代价</h2>
<p>在熟悉了<code>B+</code>树索引原理之后，本篇文章的主题是唠叨如何更好的使用索引，虽然索引是个好东西，可不能乱建，在介绍如何更好的使用索引之前先要了解一下使用这玩意儿的代价，它在空间和时间上都会拖后腿：</p>
<ul>
<li>
<p>空间上的代价</p>
<p>这个是显而易见的，每建立一个索引都要为它建立一棵<code>B+</code>树，每一棵<code>B+</code>树的每一个节点都是一个数据页，一个页默认会占用<code>16KB</code>的存储空间，一棵很大的<code>B+</code>树由许多数据页组成，那可是很大的一片存储空间呢。</p>
</li>
<li>
<p>时间上的代价</p>
<p>每次对表中的数据进行增、删、改操作时，都需要去修改各个<code>B+</code>树索引。而且我们讲过，<code>B+</code>树每层节点都是按照索引列的值从小到大的顺序排序而组成了双向链表。不论是叶子节点中的记录，还是内节点中的记录（也就是不论是用户记录还是目录项记录）都是按照索引列的值从小到大的顺序而形成了一个单向链表。而增、删、改操作可能会对节点和记录的排序造成破坏，所以存储引擎需要额外的时间进行一些记录移位，页面分裂、页面回收啥的操作来维护好节点和记录的排序。如果我们建了许多索引，每个索引对应的<code>B+</code>树都要进行相关的维护操作，这还能不给性能拖后腿么？</p>
</li>
</ul>
<p>所以说，一个表上索引建的越多，就会占用越多的存储空间，在增删改记录的时候性能就越差。为了能建立又好又少的索引，我们先得学学这些索引在哪些条件下起作用的。</p>
<h2 class="heading">B+树索引适用的条件</h2>
<p>下边我们将唠叨许多种让<code>B+</code>树索引发挥最大效能的技巧和注意事项，不过大家要清楚，所有的技巧都是源自你对<code>B+</code>树索引本质的理解，所以如果你还不能保证对<code>B+</code>树索引充分的理解，那么再次建议回过头把前边的内容看完了再来，要不然读文章对你来说是一种折磨。首先，<code>B+</code>树索引并不是万能的，并不是所有的查询语句都能用到我们建立的索引。下边介绍几个我们可能使用<code>B+</code>树索引来进行查询的情况。为了故事的顺利发展，我们需要先创建一个表，这个表是用来存储人的一些基本信息的：</p>
<pre><code class="hljs bash" lang="bash">CREATE TABLE person_info(
    id INT NOT NULL auto_increment,
    name VARCHAR(100) NOT NULL,
    birthday DATE NOT NULL,
    phone_number CHAR(11) NOT NULL,
    country varchar(100) NOT NULL,
    PRIMARY KEY (id),
    KEY idx_name_birthday_phone_number (name, birthday, phone_number)
);
</code></pre><p>对于这个<code>person_info</code>表我们需要注意两点：</p>
<ul>
<li>
<p>表中的主键是<code>id</code>列，它存储一个自动递增的整数。所以<code>InnoDB</code>存储引擎会自动为<code>id</code>列建立聚簇索引。</p>
</li>
<li>
<p>我们额外定义了一个二级索引<code>idx_name_birthday_phone_number</code>，它是由3个列组成的联合索引。所以在这个索引对应的<code>B+</code>树的叶子节点处存储的用户记录只保留<code>name</code>、<code>birthday</code>、<code>phone_number</code>这三个列的值以及主键<code>id</code>的值，并不会保存<code>country</code>列的值。</p>
</li>
</ul>
<p>从这两点注意中我们可以再次看到，一个表中有多少索引就会建立多少棵<code>B+</code>树，<code>person_info</code>表会为聚簇索引和<code>idx_name_birthday_phone_number</code>索引建立2棵<code>B+</code>树。下边我们画一下索引<code>idx_name_birthday_phone_number</code>的示意图，不过既然我们已经掌握了<code>InnoDB</code>的<code>B+</code>树索引原理，那我们在画图的时候为了让图更加清晰，所以在省略一些不必要的部分，比如记录的额外信息，各页面的页号等等，其中内节点中目录项记录的页号信息我们用箭头来代替，在记录结构中只保留<code>name</code>、<code>birthday</code>、<code>phone_number</code>、<code>id</code>这四个列的真实数据值，所以示意图就长这样（留心的同学看出来了，这其实和《高性能MySQL》里举的例子的图差不多，我觉得这个例子特别好，所以就借鉴了一下）：</p>
<p></p><figure><img alt="image_1cpk121ttgku1lj7n4l1g81152k9.png-141.1kB" src="https://user-gold-cdn.xitu.io/2019/5/5/16a86c3fe051473d?w=1131&amp;h=505&amp;f=png&amp;s=144440"><figcaption></figcaption></figure><p></p>
<p>为了方便大家理解，我们特意标明了哪些是内节点，哪些是叶子节点。再次强调一下，内节点中存储的是<code>目录项记录</code>，叶子节点中存储的是<code>用户记录</code>（由于不是聚簇索引，所以用户记录是不完整的，缺少<code>country</code>列的值）。从图中可以看出，这个<code>idx_name_birthday_phone_number</code>索引对应的<code>B+</code>树中页面和记录的排序方式就是这样的：</p>
<ul>
<li>先按照<code>name</code>列的值进行排序。</li>
<li>如果<code>name</code>列的值相同，则按照<code>birthday</code>列的值进行排序。</li>
<li>如果<code>birthday</code>列的值也相同，则按照<code>phone_number</code>的值进行排序。</li>
</ul>
<p>这个排序方式<span style="color:red">十分</span>、<span style="color:red">特别</span>、<span style="color:red">非常</span>、<span style="color:red">巨</span>、<span style="color:red">very very very</span>重要，因为<span style="color:red">只要页面和记录是排好序的，我们就可以通过二分法来快速定位查找</span>。下边的内容都仰仗这个图了，大家对照着图理解。</p>
<h3 class="heading">全值匹配</h3>
<p>如果我们的搜索条件中的列和索引列一致的话，这种情况就称为全值匹配，比方说下边这个查找语句：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name = <span class="hljs-string">'Ashburn'</span> AND birthday = <span class="hljs-string">'1990-09-27'</span> AND phone_number = <span class="hljs-string">'15123983239'</span>;
</code></pre><p>我们建立的<code>idx_name_birthday_phone_number</code>索引包含的3个列在这个查询语句中都展现出来了。大家可以想象一下这个查询过程：</p>
<ul>
<li>
<p>因为<code>B+</code>树的数据页和记录先是按照<code>name</code>列的值进行排序的，所以先可以很快定位<code>name</code>列的值是<code>Ashburn</code>的记录位置。</p>
</li>
<li>
<p>在<code>name</code>列相同的记录里又是按照<code>birthday</code>列的值进行排序的，所以在<code>name</code>列的值是<code>Ashburn</code>的记录里又可以快速定位<code>birthday</code>列的值是<code>'1990-09-27'</code>的记录。</p>
</li>
<li>
<p>如果很不幸，<code>name</code>和<code>birthday</code>列的值都是相同的，那记录是按照<code>phone_number</code>列的值排序的，所以联合索引中的三个列都可能被用到。</p>
</li>
</ul>
<p>有的同学也许有个疑问，<code>WHERE</code>子句中的几个搜索条件的顺序对查询结果有啥影响么？也就是说如果我们调换<code>name</code>、<code>birthday</code>、<code>phone_number</code>这几个搜索列的顺序对查询的执行过程有影响么？比方说写成下边这样：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE birthday = <span class="hljs-string">'1990-09-27'</span> AND phone_number = <span class="hljs-string">'15123983239'</span> AND name = <span class="hljs-string">'Ashburn'</span>;
</code></pre><p>答案是：没影响哈。<code>MySQL</code>有一个叫查询优化器的东东，会分析这些搜索条件并且按照可以使用的索引中列的顺序来决定先使用哪个搜索条件，后使用哪个搜索条件。我们后边儿会有专门的章节来介绍查询优化器，敬请期待。</p>
<h3 class="heading">匹配左边的列</h3>
<p>其实在我们的搜索语句中也可以不用包含全部联合索引中的列，只包含左边的就行，比方说下边的查询语句：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name = <span class="hljs-string">'Ashburn'</span>;
</code></pre><p>或者包含多个左边的列也行：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name = <span class="hljs-string">'Ashburn'</span> AND birthday = <span class="hljs-string">'1990-09-27'</span>;
</code></pre><p>那为什么搜索条件中必须出现左边的列才可以使用到这个<code>B+</code>树索引呢？比如下边的语句就用不到这个<code>B+</code>树索引么？</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE birthday = <span class="hljs-string">'1990-09-27'</span>;
</code></pre><p>是的，的确用不到，因为<code>B+</code>树的数据页和记录先是按照<code>name</code>列的值排序的，在<code>name</code>列的值相同的情况下才使用<code>birthday</code>列进行排序，也就是说<code>name</code>列的值不同的记录中<code>birthday</code>的值可能是无序的。而现在你跳过<code>name</code>列直接根据<code>birthday</code>的值去查找，臣妾做不到呀～ 那如果我就想在只使用<code>birthday</code>的值去通过<code>B+</code>树索引进行查找咋办呢？这好办，你再对<code>birthday</code>列建一个<code>B+</code>树索引就行了，创建索引的语法不用我唠叨了吧。</p>
<p>但是需要特别注意的一点是，<span style="color:red">如果我们想使用联合索引中尽可能多的列，搜索条件中的各个列必须是联合索引中从最左边连续的列</span>。比方说联合索引<code>idx_name_birthday_phone_number</code>中列的定义顺序是<code>name</code>、<code>birthday</code>、<code>phone_number</code>，如果我们的搜索条件中只有<code>name</code>和<code>phone_number</code>，而没有中间的<code>birthday</code>，比方说这样：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name = <span class="hljs-string">'Ashburn'</span> AND phone_number = <span class="hljs-string">'15123983239'</span>;
</code></pre><p>这样只能用到<code>name</code>列的索引，<code>birthday</code>和<code>phone_number</code>的索引就用不上了，因为<code>name</code>值相同的记录先按照<code>birthday</code>的值进行排序，<code>birthday</code>值相同的记录才按照<code>phone_number</code>值进行排序。</p>
<h3 class="heading">匹配列前缀</h3>
<p>我们前边说过为某个列建立索引的意思其实就是在对应的<code>B+</code>树的记录中使用该列的值进行排序，比方说<code>person_info</code>表上建立的联合索引<code>idx_name_birthday_phone_number</code>会先用<code>name</code>列的值进行排序，所以这个联合索引对应的<code>B+</code>树中的记录的<code>name</code>列的排列就是这样的：</p>
<pre><code class="hljs bash" lang="bash">Aaron
Aaron
...
Aaron
Asa
Ashburn
...
Ashburn
Baird
Barlow
...
Barlow
</code></pre><p>字符串排序的本质就是比较哪个字符串大一点儿，哪个字符串小一点，比较字符串大小就用到了该列的字符集和比较规则，这个我们前边儿唠叨过，就不多唠叨了。这里需要注意的是，一般的比较规则都是逐个比较字符的大小，也就是说我们比较两个字符串的大小的过程其实是这样的：</p>
<ul>
<li>
<p>先比较字符串的第一个字符，第一个字符小的那个字符串就比较小。</p>
</li>
<li>
<p>如果两个字符串的第一个字符相同，那就再比较第二个字符，第二个字符比较小的那个字符串就比较小。</p>
</li>
<li>
<p>如果两个字符串的第二个字符也相同，那就接着比较第三个字符，依此类推。</p>
</li>
</ul>
<p>所以一个排好序的字符串列其实有这样的特点：</p>
<ul>
<li>
<p>先按照字符串的第一个字符进行排序。</p>
</li>
<li>
<p>如果第一个字符相同再按照第二个字符进行排序。</p>
</li>
<li>
<p>如果第二个字符相同再按照第三个字符进行排序，依此类推。</p>
</li>
</ul>
<p>也就是说这些字符串的前n个字符，也就是前缀都是排好序的，所以对于字符串类型的索引列来说，我们只匹配它的前缀也是可以快速定位记录的，比方说我们想查询名字以<code>'As'</code>开头的记录，那就可以这么写查询语句：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name LIKE <span class="hljs-string">'As%'</span>;
</code></pre><p>但是需要注意的是，如果只给出后缀或者中间的某个字符串，比如这样：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name LIKE <span class="hljs-string">'%As%'</span>;
</code></pre><p><code>MySQL</code>就无法快速定位记录位置了，因为字符串中间有<code>'As'</code>的字符串并没有排好序，所以只能全表扫描了。有时候我们有一些匹配某些字符串后缀的需求，比方说某个表有一个<code>url</code>列，该列中存储了许多url：</p>
<pre><code class="hljs bash" lang="bash">+----------------+
| url            |
+----------------+
| www.baidu.com  |
| www.google.com |
| www.gov.cn     |
| ...            |
| www.wto.org    |
+----------------+
</code></pre><p>假设已经对该<code>url</code>列创建了索引，如果我们想查询以<code>com</code>为后缀的网址的话可以这样写查询条件：<code>WHERE url LIKE '%com'</code>，但是这样的话无法使用该<code>url</code>列的索引。为了在查询时用到这个索引而不至于全表扫描，我们可以把后缀查询改写成前缀查询，不过我们就得把表中的数据全部逆序存储一下，也就是说我们可以这样保存<code>url</code>列中的数据：</p>
<pre><code class="hljs bash" lang="bash">+----------------+
| url            |
+----------------+
| moc.udiab.www  |
| moc.elgoog.www |
| nc.vog.www     |
| ...            |
| gro.otw.www    |
+----------------+
</code></pre><p>这样再查找以<code>com</code>为后缀的网址时搜索条件便可以这么写：<code>WHERE url LIKE 'moc%'</code>，这样就可以用到索引了。</p>
<h3 class="heading">匹配范围值</h3>
<p>回头看我们<code>idx_name_birthday_phone_number</code>索引的<code>B+</code>树示意图，<span style="color:red">所有记录都是按照索引列的值从小到大的顺序排好序的</span>，所以这极大的方便我们查找索引列的值在某个范围内的记录。比方说下边这个查询语句：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name &gt; <span class="hljs-string">'Asa'</span> AND name &lt; <span class="hljs-string">'Barlow'</span>;
</code></pre><p>由于<code>B+</code>树中的数据页和记录是先按<code>name</code>列排序的，所以我们上边的查询过程其实是这样的：</p>
<ul>
<li>找到<code>name</code>值为<code>Asa</code>的记录。</li>
<li>找到<code>name</code>值为<code>Barlow</code>的记录。</li>
<li>哦啦，由于所有记录都是由链表连起来的（记录之间用单链表，数据页之间用双链表），所以他们之间的记录都可以很容易的取出来喽～</li>
<li>找到这些记录的主键值，再到<code>聚簇索引</code>中<code>回表</code>查找完整的记录。</li>
</ul>
<p>不过在使用联合进行范围查找的时候需要注意，<span style="color:red">如果对多个列同时进行范围查找的话，只有对索引最左边的那个列进行范围查找的时候才能用到<code>B+</code>树索引</span>，比方说这样：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name &gt; <span class="hljs-string">'Asa'</span> AND name &lt; <span class="hljs-string">'Barlow'</span> AND birthday &gt; <span class="hljs-string">'1980-01-01'</span>;
</code></pre><p>上边这个查询可以分成两个部分：</p>
<ol>
<li>
<p>通过条件<code>name &gt; 'Asa' AND name &lt; 'Barlow'</code>来对<code>name</code>进行范围，查找的结果可能有多条<code>name</code>值不同的记录，</p>
</li>
<li>
<p>对这些<code>name</code>值不同的记录继续通过<code>birthday &gt; '1980-01-01'</code>条件继续过滤。</p>
</li>
</ol>
<p>这样子对于联合索引<code>idx_name_birthday_phone_number</code>来说，只能用到<code>name</code>列的部分，而用不到<code>birthday</code>列的部分，因为只有<code>name</code>值相同的情况下才能用<code>birthday</code>列的值进行排序，而这个查询中<span style="color:red">通过<code>name</code>进行范围查找的记录中可能并不是按照<code>birthday</code>列进行排序的</span>，所以在搜索条件中继续以<code>birthday</code>列进行查找时是用不到这个<code>B+</code>树索引的。</p>
<h3 class="heading">精确匹配某一列并范围匹配另外一列</h3>
<p>对于同一个联合索引来说，虽然对多个列都进行范围查找时只能用到最左边那个索引列，但是如果左边的列是精确查找，则右边的列可以进行范围查找，比方说这样：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name = <span class="hljs-string">'Ashburn'</span> AND birthday &gt; <span class="hljs-string">'1980-01-01'</span> AND birthday &lt; <span class="hljs-string">'2000-12-31'</span> AND phone_number &gt; <span class="hljs-string">'15100000000'</span>;
</code></pre><p>这个查询的条件可以分为3个部分：</p>
<ol>
<li>
<p><code>name = 'Ashburn'</code>，对<code>name</code>列进行精确查找，当然可以使用<code>B+</code>树索引了。</p>
</li>
<li>
<p><code>birthday &gt; '1980-01-01' AND birthday &lt; '2000-12-31'</code>，由于<code>name</code>列是精确查找，所以通过<code>name = 'Ashburn'</code>条件查找后得到的结果的<code>name</code>值都是相同的，它们会再按照<code>birthday</code>的值进行排序。所以此时对<code>birthday</code>列进行范围查找是可以用到<code>B+</code>树索引的。</p>
</li>
<li>
<p><code>phone_number &gt; '15100000000'</code>，通过<code>birthday</code>的范围查找的记录的<code>birthday</code>的值可能不同，所以这个条件无法再利用<code>B+</code>树索引了，只能遍历上一步查询得到的记录。</p>
</li>
</ol>
<p>同理，下边的查询也是可能用到这个<code>idx_name_birthday_phone_number</code>联合索引的：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name = <span class="hljs-string">'Ashburn'</span> AND birthday = <span class="hljs-string">'1980-01-01'</span> AND phone_number &gt; <span class="hljs-string">'15100000000'</span>;
</code></pre><h3 class="heading">用于排序</h3>
<p>我们在写查询语句的时候经常需要对查询出来的记录通过<code>ORDER BY</code>子句按照某种规则进行排序。一般情况下，我们只能把记录都加载到内存中，再用一些排序算法，比如快速排序、归并排序、吧啦吧啦排序等等在内存中对这些记录进行排序，有的时候可能查询的结果集太大以至于不能在内存中进行排序的话，还可能暂时借助磁盘的空间来存放中间结果，排序操作完成后再把排好序的结果集返回到客户端。在<code>MySQL</code>中，把这种在内存中或者磁盘上进行排序的方式统称为文件排序（英文名：<code>filesort</code>），跟<code>文件</code>这个词儿一沾边儿，就显得这些排序操作非常慢了（磁盘和内存的速度比起来，就像是飞机和蜗牛的对比）。但是如果<code>ORDER BY</code>子句里使用到了我们的索引列，就有可能省去在内存或文件中排序的步骤，比如下边这个简单的查询语句：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info ORDER BY name, birthday, phone_number LIMIT 10;
</code></pre><p>这个查询的结果集需要先按照<code>name</code>值排序，如果记录的<code>name</code>值相同，则需要按照<code>birthday</code>来排序，如果<code>birthday</code>的值相同，则需要按照<code>phone_number</code>排序。大家可以回过头去看我们建立的<code>idx_name_birthday_phone_number</code>索引的示意图，因为这个<code>B+</code>树索引本身就是按照上述规则排好序的，所以直接从索引中提取数据，然后进行<code>回表</code>操作取出该索引中不包含的列就好了。简单吧？是的，索引就是这么牛逼。</p>
<h4 class="heading">使用联合索引进行排序注意事项</h4>
<p>对于<code>联合索引</code>有个问题需要注意，<code>ORDER BY</code>的子句后边的列的顺序也必须按照索引列的顺序给出，如果给出<code>ORDER BY phone_number, birthday, name</code>的顺序，那也是用不了<code>B+</code>树索引，这种颠倒顺序就不能使用索引的原因我们上边详细说过了，这就不赘述了。</p>
<p>同理，<code>ORDER BY name</code>、<code>ORDER BY name, birthday</code>这种匹配索引左边的列的形式可以使用部分的<code>B+</code>树索引。当联合索引左边列的值为常量，也可以使用后边的列进行排序，比如这样：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name = <span class="hljs-string">'A'</span> ORDER BY birthday, phone_number LIMIT 10;
</code></pre><p>这个查询能使用联合索引进行排序是因为<code>name</code>列的值相同的记录是按照<code>birthday</code>, <code>phone_number</code>排序的，说了好多遍了都。</p>
<h4 class="heading">不可以使用索引进行排序的几种情况</h4>
<h5 class="heading">ASC、DESC混用</h5>
<p>对于使用联合索引进行排序的场景，我们要求各个排序列的排序顺序是一致的，也就是要么各个列都是<code>ASC</code>规则排序，要么都是<code>DESC</code>规则排序。</p>
<pre><code class="hljs bash" lang="bash">小贴士：

ORDER BY子句后的列如果不加ASC或者DESC默认是按照ASC排序规则排序的，也就是升序排序的。
</code></pre><p>为啥会有这种奇葩规定呢？这个还得回头想想这个<code>idx_name_birthday_phone_number</code>联合索引中记录的结构：</p>
<ul>
<li>
<p>先按照记录的<code>name</code>列的值进行升序排列。</p>
</li>
<li>
<p>如果记录的<code>name</code>列的值相同，再按照<code>birthday</code>列的值进行升序排列。</p>
</li>
<li>
<p>如果记录的<code>birthday</code>列的值相同，再按照<code>phone_number</code>列的值进行升序排列。</p>
</li>
</ul>
<p>如果查询中的各个排序列的排序顺序是一致的，比方说下边这两种情况：</p>
<ul>
<li>
<p><code>ORDER BY name, birthday LIMIT 10</code></p>
<p>这种情况直接从索引的最左边开始往右读10行记录就可以了。</p>
</li>
<li>
<p><code>ORDER BY name DESC, birthday DESC LIMIT 10</code>，</p>
<p>这种情况直接从索引的最右边开始往左读10行记录就可以了。</p>
</li>
</ul>
<p>但是如果我们查询的需求是先按照<code>name</code>列进行升序排列，再按照<code>birthday</code>列进行降序排列的话，比如说这样的查询语句：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info ORDER BY name, birthday DESC LIMIT 10;
</code></pre><p>这样如果使用索引排序的话过程就是这样的：</p>
<ul>
<li>
<p>先从索引的最左边确定<code>name</code>列最小的值，然后找到<code>name</code>列等于该值的所有记录，然后从<code>name</code>列等于该值的最右边的那条记录开始往左找10条记录。</p>
</li>
<li>
<p>如果<code>name</code>列等于最小的值的记录不足10条，再继续往右找<code>name</code>值第二小的记录，重复上边那个过程，直到找到10条记录为止。</p>
</li>
</ul>
<p>累不累？累！重点是这样不能高效使用索引，而要采取更复杂的算法去从索引中取数据，设计<code>MySQL</code>的大叔觉得这样还不如直接文件排序来的快，所以就规定使用联合索引的各个排序列的排序顺序必须是一致的。</p>
<h5 class="heading">WHERE子句中出现非排序使用到的索引列</h5>
<p>如果WHERE子句中出现了非排序使用到的索引列，那么排序依然是使用不到索引的，比方说这样：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE country = <span class="hljs-string">'China'</span> ORDER BY name LIMIT 10;
</code></pre><p>这个查询只能先把符合搜索条件<code>country = 'China'</code>的记录提取出来后再进行排序，是使用不到索引。注意和下边这个查询作区别：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name = <span class="hljs-string">'A'</span> ORDER BY birthday, phone_number LIMIT 10;
</code></pre><p>虽然这个查询也有搜索条件，但是<code>name = 'A'</code>可以使用到索引<code>idx_name_birthday_phone_number</code>，而且过滤剩下的记录还是按照<code>birthday</code>、<code>phone_number</code>列排序的，所以还是可以使用索引进行排序的。</p>
<h5 class="heading">排序列包含非同一个索引的列</h5>
<p>有时候用来排序的多个列不是一个索引里的，这种情况也不能使用索引进行排序，比方说：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info ORDER BY name, country LIMIT 10;
</code></pre><p><code>name</code>和<code>country</code>并不属于一个联合索引中的列，所以无法使用索引进行排序，至于为啥我就不想再唠叨了，自己用前边的理论自己捋一捋把～</p>
<h5 class="heading">排序列使用了复杂的表达式</h5>
<p>要想使用索引进行排序操作，必须保证索引列是以单独列的形式出现，而不是修饰过的形式，比方说这样：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info ORDER BY UPPER(name) LIMIT 10;
</code></pre><p>使用了<code>UPPER</code>函数修饰过的列就不是单独的列啦，这样就无法使用索引进行排序啦。</p>
<h3 class="heading">用于分组</h3>
<p>有时候我们为了方便统计表中的一些信息，会把表中的记录按照某些列进行分组。比如下边这个分组查询：</p>
<pre><code class="hljs bash" lang="bash">SELECT name, birthday, phone_number, COUNT(*) FROM person_info GROUP BY name, birthday, phone_number
</code></pre><p>这个查询语句相当于做了3次分组操作：</p>
<ol>
<li>
<p>先把记录按照<code>name</code>值进行分组，所有<code>name</code>值相同的记录划分为一组。</p>
</li>
<li>
<p>将每个<code>name</code>值相同的分组里的记录再按照<code>birthday</code>的值进行分组，将<code>birthday</code>值相同的记录放到一个小分组里，所以看起来就像在一个大分组里又化分了好多小分组。</p>
</li>
<li>
<p>再将上一步中产生的小分组按照<code>phone_number</code>的值分成更小的分组，所以整体上看起来就像是先把记录分成一个大分组，然后把<code>大分组</code>分成若干个<code>小分组</code>，然后把若干个<code>小分组</code>再细分成更多的<code>小小分组</code>。</p>
</li>
</ol>
<p>然后针对那些<code>小小分组</code>进行统计，比如在我们这个查询语句中就是统计每个<code>小小分组</code>包含的记录条数。如果没有索引的话，这个分组过程全部需要在内存里实现，而如果有了索引的话，恰巧这个分组顺序又和我们的<code>B+</code>树中的索引列的顺序是一致的，而我们的<code>B+</code>树索引又是按照索引列排好序的，这不正好么，所以可以直接使用<code>B+</code>树索引进行分组。</p>
<p>和使用<code>B+</code>树索引进行排序是一个道理，分组列的顺序也需要和索引列的顺序一致，也可以只使用索引列中左边的列进行分组，吧啦吧啦的～</p>
<h2 class="heading">回表的代价</h2>
<p>上边的讨论对<code>回表</code>这个词儿多是一带而过，可能大家没啥深刻的体会，下边我们详细唠叨下。还是用<code>idx_name_birthday_phone_number</code>索引为例，看下边这个查询：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name &gt; <span class="hljs-string">'Asa'</span> AND name &lt; <span class="hljs-string">'Barlow'</span>;
</code></pre><p>在使用<code>idx_name_birthday_phone_number</code>索引进行查询时大致可以分为这两个步骤：</p>
<ol>
<li>
<p>从索引<code>idx_name_birthday_phone_number</code>对应的<code>B+</code>树中取出<code>name</code>值在<code>Asa</code>～<code>Barlow</code>之间的用户记录。</p>
</li>
<li>
<p>由于索引<code>idx_name_birthday_phone_number</code>对应的<code>B+</code>树用户记录中只包含<code>name</code>、<code>birthday</code>、<code>phone_number</code>、<code>id</code>这4个字段，而查询列表是<code>*</code>，意味着要查询表中所有字段，也就是还要包括<code>country</code>字段。这时需要把从上一步中获取到的每一条记录的<code>id</code>字段都到聚簇索引对应的<code>B+</code>树中找到完整的用户记录，也就是我们通常所说的<code>回表</code>，然后把完整的用户记录返回给查询用户。</p>
</li>
</ol>
<p>由于索引<code>idx_name_birthday_phone_number</code>对应的<code>B+</code>树中的记录首先会按照<code>name</code>列的值进行排序，所以值在<code>Asa</code>～<code>Barlow</code>之间的记录在磁盘中的存储是相连的，集中分布在一个或几个数据页中，我们可以很快的把这些连着的记录从磁盘中读出来，这种读取方式我们也可以称为<code>顺序I/O</code>。根据第1步中获取到的记录的<code>id</code>字段的值可能并不相连，而在聚簇索引中记录是根据<code>id</code>（也就是主键）的顺序排列的，所以根据这些并不连续的<code>id</code>值到聚簇索引中访问完整的用户记录可能分布在不同的数据页中，这样读取完整的用户记录可能要访问更多的数据页，这种读取方式我们也可以称为<code>随机I/O</code>。一般情况下，顺序I/O比随机I/O的性能高很多，所以步骤1的执行可能很快，而步骤2就慢一些。所以这个使用索引<code>idx_name_birthday_phone_number</code>的查询有这么两个特点：</p>
<ul>
<li>
<p>会使用到两个<code>B+</code>树索引，一个二级索引，一个聚簇索引。</p>
</li>
<li>
<p>访问二级索引使用<code>顺序I/O</code>，访问聚簇索引使用<code>随机I/O</code>。</p>
</li>
</ul>
<p><span style="color:red">需要回表的记录越多，使用二级索引的性能就越低</span>，甚至让某些查询宁愿使用全表扫描也不使用<code>二级索引</code>。比方说<code>name</code>值在<code>Asa</code>～<code>Barlow</code>之间的用户记录数量占全部记录数量90%以上，那么如果使用<code>idx_name_birthday_phone_number</code>索引的话，有90%多的<code>id</code>值需要回表，这不是吃力不讨好么，还不如直接去扫描聚簇索引（也就是全表扫描）。</p>
<p>那什么时候采用全表扫描的方式，什么时候使用采用<code>二级索引 + 回表</code>的方式去执行查询呢？这个就是传说中的查询优化器做的工作，查询优化器会事先对表中的记录计算一些统计数据，然后再利用这些统计数据根据查询的条件来计算一下需要回表的记录数，需要回表的记录数越多，就越倾向于使用全表扫描，反之倾向于使用<code>二级索引 + 回表</code>的方式。当然优化器做的分析工作不仅仅是这么简单，但是大致上是个这个过程。一般情况下，限制查询获取较少的记录数会让优化器更倾向于选择使用<code>二级索引 + 回表</code>的方式进行查询，因为回表的记录越少，性能提升就越高，比方说上边的查询可以改写成这样：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info WHERE name &gt; <span class="hljs-string">'Asa'</span> AND name &lt; <span class="hljs-string">'Barlow'</span> LIMIT 10;
</code></pre><p>添加了<code>LIMIT 10</code>的查询更容易让优化器采用<code>二级索引 + 回表</code>的方式进行查询。</p>
<p>对于有排序需求的查询，上边讨论的采用<code>全表扫描</code>还是<code>二级索引 + 回表</code>的方式进行查询的条件也是成立的，比方说下边这个查询：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info ORDER BY name, birthday, phone_number;
</code></pre><p>由于查询列表是<code>*</code>，所以如果使用二级索引进行排序的话，需要把排序完的二级索引记录全部进行回表操作，这样操作的成本还不如直接遍历聚簇索引然后再进行文件排序（<code>filesort</code>）低，所以优化器会倾向于使用<code>全表扫描</code>的方式执行查询。如果我们加了<code>LIMIT</code>子句，比如这样：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info ORDER BY name, birthday, phone_number LIMIT 10;
</code></pre><p>这样需要回表的记录特别少，优化器就会倾向于使用<code>二级索引 + 回表</code>的方式执行查询。</p>
<h3 class="heading">覆盖索引</h3>
<p>为了彻底告别<code>回表</code>操作带来的性能损耗，我们建议：<span style="color:red">最好在查询列表里只包含索引列</span>，比如这样：</p>
<pre><code class="hljs bash" lang="bash">SELECT name, birthday, phone_number FROM person_info WHERE name &gt; <span class="hljs-string">'Asa'</span> AND name &lt; <span class="hljs-string">'Barlow'</span>
</code></pre><p>因为我们只查询<code>name</code>, <code>birthday</code>, <code>phone_number</code>这三个索引列的值，所以在通过<code>idx_name_birthday_phone_number</code>索引得到结果后就不必到<code>聚簇索引</code>中再查找记录的剩余列，也就是<code>country</code>列的值了，这样就省去了<code>回表</code>操作带来的性能损耗。我们把这种只需要用到索引的查询方式称为<code>索引覆盖</code>。排序操作也优先使用<code>覆盖索引</code>的方式进行查询，比方说这个查询：</p>
<pre><code class="hljs bash" lang="bash">SELECT name, birthday, phone_number  FROM person_info ORDER BY name, birthday, phone_number;
</code></pre><p>虽然这个查询中没有<code>LIMIT</code>子句，但是采用了<code>覆盖索引</code>，所以查询优化器就会直接使用<code>idx_name_birthday_phone_number</code>索引进行排序而不需要回表操作了。</p>
<p>当然，如果业务需要查询出索引以外的列，那还是以保证业务需求为重。但是<span style="color:red">我们很不鼓励用<code>*</code>号作为查询列表，最好把我们需要查询的列依次标明</span>。</p>
<h2 class="heading">如何挑选索引</h2>
<p>上边我们以<code>idx_name_birthday_phone_number</code>索引为例对索引的适用条件进行了详细的唠叨，下边看一下我们在建立索引时或者编写查询语句时就应该注意的一些事项。</p>
<h3 class="heading">只为用于搜索、排序或分组的列创建索引</h3>
<p>也就是说，只为出现在<code>WHERE</code>子句中的列、连接子句中的连接列，或者出现在<code>ORDER BY</code>或<code>GROUP BY</code>子句中的列创建索引。而出现在查询列表中的列就没必要建立索引了：</p>
<pre><code class="hljs bash" lang="bash">SELECT birthday, country FROM person_name WHERE name = <span class="hljs-string">'Ashburn'</span>;
</code></pre><p>像查询列表中的<code>birthday</code>、<code>country</code>这两个列就不需要建立索引，我们只需要为出现在<code>WHERE</code>子句中的<code>name</code>列创建索引就可以了。</p>
<h3 class="heading">考虑列的基数</h3>
<p><code>列的基数</code>指的是某一列中不重复数据的个数，比方说某个列包含值<code>2, 5, 8, 2, 5, 8, 2, 5, 8</code>，虽然有<code>9</code>条记录，但该列的基数却是<code>3</code>。也就是说，<span style="color:red">在记录行数一定的情况下，列的基数越大，该列中的值越分散，列的基数越小，该列中的值越集中</span>。这个<code>列的基数</code>指标非常重要，直接影响我们是否能有效的利用索引。假设某个列的基数为<code>1</code>，也就是所有记录在该列中的值都一样，那为该列建立索引是没有用的，因为所有值都一样就无法排序，无法进行快速查找了～ 而且如果某个建立了二级索引的列的重复值特别多，那么使用这个二级索引查出的记录还可能要做回表操作，这样性能损耗就更大了。所以结论就是：<span style="color:red">最好为那些列的基数大的列建立索引，为基数太小列的建立索引效果可能不好</span>。</p>
<h3 class="heading">索引列的类型尽量小</h3>
<p>我们在定义表结构的时候要显式的指定列的类型，以整数类型为例，有<code>TINYINT</code>、<code>MEDIUMINT</code>、<code>INT</code>、<code>BIGINT</code>这么几种，它们占用的存储空间依次递增，我们这里所说的<code>类型大小</code>指的就是<span style="color:red">该类型表示的数据范围的大小</span>。能表示的整数范围当然也是依次递增，如果我们想要对某个整数列建立索引的话，<span style="color:red">在表示的整数范围允许的情况下，尽量让索引列使用较小的类型</span>，比如我们能使用<code>INT</code>就不要使用<code>BIGINT</code>，能使用<code>MEDIUMINT</code>就不要使用<code>INT</code>～ 这是因为：</p>
<ul>
<li>
<p>数据类型越小，在查询时进行的比较操作越快（这是CPU层次的东东）</p>
</li>
<li>
<p>数据类型越小，索引占用的存储空间就越少，在一个数据页内就可以放下更多的记录，从而减少磁盘<code>I/O</code>带来的性能损耗，也就意味着可以把更多的数据页缓存在内存中，从而加快读写效率。</p>
</li>
</ul>
<p>这个建议对于表的主键来说更加适用，因为不仅是聚簇索引中会存储主键值，其他所有的二级索引的节点处都会存储一份记录的主键值，如果主键适用更小的数据类型，也就意味着节省更多的存储空间和更高效的<code>I/O</code>。</p>
<h3 class="heading">索引字符串值的前缀</h3>
<p>我们知道一个字符串其实是由若干个字符组成，如果我们在<code>MySQL</code>中使用<code>utf8</code>字符集去存储字符串的话，编码一个字符需要占用<code>1~3</code>个字节。假设我们的字符串很长，那存储一个字符串就需要占用很大的存储空间。在我们需要为这个字符串列建立索引时，那就意味着在对应的<code>B+</code>树中有这么两个问题：</p>
<ul>
<li>
<p><code>B+</code>树索引中的记录需要把该列的完整字符串存储起来，而且字符串越长，在索引中占用的存储空间越大。</p>
</li>
<li>
<p>如果<code>B+</code>树索引中索引列存储的字符串很长，那在做字符串比较时会占用更多的时间。</p>
</li>
</ul>
<p>我们前边儿说过索引列的字符串前缀其实也是排好序的，所以索引的设计者提出了个方案 --- <span style="color:red">只对字符串的前几个字符进行索引</span>也就是说在二级索引的记录中只保留字符串前几个字符。这样在查找记录时虽然不能精确的定位到记录的位置，但是能定位到相应前缀所在的位置，然后根据前缀相同的记录的主键值回表查询完整的字符串值，再对比就好了。这样只在<code>B+</code>树中存储字符串的前几个字符的编码，既节约空间，又减少了字符串的比较时间，还大概能解决排序的问题，何乐而不为，比方说我们在建表语句中只对<code>name</code>列的前10个字符进行索引可以这么写：</p>
<pre><code class="hljs bash" lang="bash">CREATE TABLE person_info(
    name VARCHAR(100) NOT NULL,
    birthday DATE NOT NULL,
    phone_number CHAR(11) NOT NULL,
    country varchar(100) NOT NULL,
    KEY idx_name_birthday_phone_number (name(10), birthday, phone_number)
);    
</code></pre><p><code>name(10)</code>就表示在建立的<code>B+</code>树索引中只保留记录的前<code>10</code>个字符的编码，这种<span style="color:red">只索引字符串值的前缀的策略是我们非常鼓励的，尤其是在字符串类型能存储的字符比较多的时候</span>。</p>
<h4 class="heading">索引列前缀对排序的影响</h4>
<p>如果使用了索引列前缀，比方说前边只把<code>name</code>列的前10个字符放到了二级索引中，下边这个查询可能就有点儿尴尬了：</p>
<pre><code class="hljs bash" lang="bash">SELECT * FROM person_info ORDER BY name LIMIT 10;
</code></pre><p>因为二级索引中不包含完整的<code>name</code>列信息，所以无法对前十个字符相同，后边的字符不同的记录进行排序，也就是使用索引列前缀的方式无法支持使用索引排序，只好乖乖的用文件排序喽。</p>
<h3 class="heading">让索引列在比较表达式中单独出现</h3>
<p>假设表中有一个整数列<code>my_col</code>，我们为这个列建立了索引。下边的两个<code>WHERE</code>子句虽然语义是一致的，但是在效率上却有差别：</p>
<ol>
<li>
<p><code>WHERE my_col * 2 &lt; 4</code></p>
</li>
<li>
<p><code>WHERE my_col &lt; 4/2</code></p>
</li>
</ol>
<p>第1个<code>WHERE</code>子句中<code>my_col</code>列并<span style="color:red">不是</span>以单独列的形式出现的，而是以<code>my_col * 2</code>这样的表达式的形式出现的，存储引擎<span style="color:red">会依次遍历所有的记录，计算这个表达式的值是不是小于<code>4</code></span>，所以这种情况下是使用不到为<code>my_col</code>列建立的<code>B+</code>树索引的。而第2个<code>WHERE</code>子句中<code>my_col</code>列并<span style="color:red">是</span>以单独列的形式出现的，这样的情况可以直接使用<code>B+</code>树索引。</p>
<p>所以结论就是：<span style="color:red">如果索引列在比较表达式中不是以单独列的形式出现，而是以某个表达式，或者函数调用形式出现的话，是用不到索引的</span>。</p>
<h3 class="heading">主键插入顺序</h3>
<p>我们知道，对于一个使用<code>InnoDB</code>存储引擎的表来说，在我们没有显式的创建索引时，表中的数据实际上都是存储在<code>聚簇索引</code>的叶子节点的。而记录又是存储在数据页中的，数据页和记录又是按照记录主键值从小到大的顺序进行排序，所以如果我们插入的记录的主键值是依次增大的话，那我们每插满一个数据页就换到下一个数据页继续插，而如果我们插入的主键值忽大忽小的话，这就比较麻烦了，假设某个数据页存储的记录已经满了，它存储的主键值在<code>1~100</code>之间：</p>
<p></p><figure><img alt="image_1capq3r1o1geqdck1cnc1fkihj39.png-28.1kB" src="https://user-gold-cdn.xitu.io/2019/5/5/16a86c3fe0e15c7d?w=866&amp;h=247&amp;f=png&amp;s=28810"><figcaption></figcaption></figure><p></p>
<p>如果此时再插入一条主键值为<code>9</code>的记录，那它插入的位置就如下图：</p>
<p></p><figure><img alt="image_1capq7nnv13en8b31lvtj2i1e8lm.png-35.3kB" src="https://user-gold-cdn.xitu.io/2019/5/5/16a86c3fe223eb7c?w=836&amp;h=401&amp;f=png&amp;s=36152"><figcaption></figcaption></figure><p></p>
<p>可这个数据页已经满了啊，再插进来咋办呢？我们需要把当前页面分裂成两个页面，把本页中的一些记录移动到新创建的这个页中。页面分裂和记录移位意味着什么？意味着：<span style="color:red">性能损耗</span>！所以如果我们想尽量避免这样无谓的性能损耗，最好让插入的记录的主键值依次递增，这样就不会发生这样的性能损耗了。所以我们建议：<span style="color:red">让主键具有<code>AUTO_INCREMENT</code>，让存储引擎自己为表生成主键，而不是我们手动插入 </span>，比方说我们可以这样定义<code>person_info</code>表：</p>
<pre><code class="hljs bash" lang="bash">CREATE TABLE person_info(
    id INT UNSIGNED NOT NULL AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    birthday DATE NOT NULL,
    phone_number CHAR(11) NOT NULL,
    country varchar(100) NOT NULL,
    PRIMARY KEY (id),
    KEY idx_name_birthday_phone_number (name(10), birthday, phone_number)
);    
</code></pre><p>我们自定义的主键列<code>id</code>拥有<code>AUTO_INCREMENT</code>属性，在插入记录时存储引擎会自动为我们填入自增的主键值。</p>
<h3 class="heading">冗余和重复索引</h3>
<p>有时候有的同学有意或者无意的就对同一个列创建了多个索引，比方说这样写建表语句：</p>
<pre><code class="hljs bash" lang="bash">CREATE TABLE person_info(
    id INT UNSIGNED NOT NULL AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    birthday DATE NOT NULL,
    phone_number CHAR(11) NOT NULL,
    country varchar(100) NOT NULL,
    PRIMARY KEY (id),
    KEY idx_name_birthday_phone_number (name(10), birthday, phone_number),
    KEY idx_name (name(10))
);    
</code></pre><p>我们知道，通过<code>idx_name_birthday_phone_number</code>索引就可以对<code>name</code>列进行快速搜索，再创建一个专门针对<code>name</code>列的索引就算是一个<code>冗余</code>索引，维护这个索引只会增加维护的成本，并不会对搜索有什么好处。</p>
<p>另一种情况，我们可能会对某个列重复建立索引，比方说这样：</p>
<pre><code class="hljs bash" lang="bash">CREATE TABLE repeat_index_demo (
    c1 INT PRIMARY KEY,
    c2 INT,
    UNIQUE uidx_c1 (c1),
    INDEX idx_c1 (c1)
);  
</code></pre><p>我们看到，<code>c1</code>既是主键、又给它定义为一个唯一索引，还给它定义了一个普通索引，可是主键本身就会生成聚簇索引，所以定义的唯一索引和普通索引是重复的，这种情况要避免。</p>
<h2 class="heading">总结</h2>
<p>上边只是我们在创建和使用<code>B+</code>树索引的过程中需要注意的一些点，后边我们还会陆续介绍更多的优化方法和注意事项，敬请期待。本集内容总结如下：</p>
<ol>
<li>
<p><code>B+</code>树索引在空间和时间上都有代价，所以没事儿别瞎建索引。</p>
</li>
<li>
<p><code>B+</code>树索引适用于下边这些情况：</p>
<ul>
<li>全值匹配</li>
<li>匹配左边的列</li>
<li>匹配范围值</li>
<li>精确匹配某一列并范围匹配另外一列</li>
<li>用于排序</li>
<li>用于分组</li>
</ul>
</li>
<li>
<p>在使用索引时需要注意下边这些事项：</p>
<ul>
<li>只为用于搜索、排序或分组的列创建索引</li>
<li>为列的基数大的列创建索引</li>
<li>索引列的类型尽量小</li>
<li>可以只对字符串值的前缀建立索引</li>
<li>只有索引列在比较表达式中单独出现才可以适用索引</li>
<li>为了尽可能少的让<code>聚簇索引</code>发生页面分裂和记录移位的情况，建议让主键拥有<code>AUTO_INCREMENT</code>属性。</li>
<li>定位并删除表中的重复和冗余索引</li>
<li>尽量使用<code>覆盖索引</code>进行查询，避免<code>回表</code>带来的性能损耗。</li>
</ul>
</li>
</ol>
